


# region 浪淘沙子策略
class Strategy_大学生多头():
    backtest_name = 'Strategy_大学生多头'
    strategy_list = [
        # ===1.大学生(资金占比0.25)
        {
            "strategy": "Strategy_大学生多头",
            "offset_list": range(1, 24, 1),
            "hold_period": '24H',
            "is_use_spot": True,
            'cap_weight': 0.25,
            'long_cap_weight': 1,
            'short_cap_weight': 0,
            'long_select_coin_num': 0.1,
            'short_select_coin_num': 0,
            "factor_list": [
                ('CirculatingMcap', True, 1, 1),
            ],
            "filter_list": [
                ('ZfStd', 18, 'pct:<0.8'),
            ],
            "filter_list_post": [
                ('ZfMeanQ', 936, 'val:>0.5'),
            ],
            "use_custom_func": False,
        },
    ]

class Strategy_GA多头():
    backtest_name = 'Strategy_GA多头'
    strategy_list = [
        # ===GA多头
        {
            "strategy": "Strategy_GA多头",
            "offset_list": [6],
            "hold_period": '24H',
            "is_use_spot": True,
            'cap_weight': 0.25,
            'long_cap_weight': 1,
            'short_cap_weight': 0,
            'long_select_coin_num': 0.1,
            'short_select_coin_num': 0,
            "factor_list": [
                ('RankDiff_spot', True, 1176, 1),
            ],
            "filter_list_post": [
                ('ZfMeanQ', 648, 'val:>0.5'),
            ],
            "use_custom_func": False,
        },
    ]


class Strategy_黄果树系列1():
    backtest_name = 'Strategy_黄果树系列1'
    strategy_list = [
        # ===Strategy_黄果树系列1
        {
            "strategy": "Strategy_黄果树系列1",
            "offset_list": [4],
            "hold_period": '24H',
            "is_use_spot": False,
            'cap_weight': 0.3,
            'long_cap_weight': 0,
            'short_cap_weight': 1,
            'long_select_coin_num': 0,
            'short_select_coin_num': 0.5,
            "factor_list": [
                ('MinMax', False, 432, 1),
            ],
            "filter_list": [
                ('QuoteVolumeMean', 432, 'pct:<0.2', False),
            ],
            "filter_list_post": [
                ('ZscoreAbsMeanQ', 432, 'val:<0.5'),
            ],
            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        },
    ]

class Strategy_黄果树系列2():
    backtest_name = 'Strategy_黄果树系列2'
    strategy_list = [
        # ===Strategy_黄果树系列2
        {
            "strategy": "Strategy_黄果树系列2",
            "offset_list": [19],
            "hold_period": '24H',
            "is_use_spot": False,
            'cap_weight': 0.1,
            'long_cap_weight': 0,
            'short_cap_weight': 1,
            'long_select_coin_num': 0,
            'short_select_coin_num': 0.5,
            "factor_list": [
                ('QuoteVolumeMean', True, 528, 1),
            ],
            "filter_list": [
                ('BiasQ', 528, 'pct:<0.2'),
            ],
            "filter_list_post": [
                ('ZscoreAbsMeanQ', 528, 'val:<0.5'),
            ],
            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        },
    ]


class Strategy_黄果树系列3():
    backtest_name = 'Strategy_黄果树系列3'
    strategy_list = [
        # ===Strategy_黄果树系列3
        {
            "strategy": "Strategy_黄果树系列3",
            "offset_list": [12],
            "hold_period": '24H',
            "is_use_spot": False,
            'cap_weight': 0.1,
            'long_cap_weight': 0,
            'short_cap_weight': 1,
            'long_select_coin_num': 0,
            'short_select_coin_num': 9999,
            "factor_list": [
                ('QuoteVolumeMean', True, 1, 1),
            ],
            "filter_list": [
                ('MinMax', 552, 'pct:<0.15'),
                ('QuoteVolumeMean', 552, 'pct:<0.15', False),
            ],
            "filter_list_post": [
                ('ZfMeanQ', 552, 'val:<0.5'),
            ],
            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        },
    ]

class Strategy_黄果树系列4():
    backtest_name = 'Strategy_黄果树系列4'
    strategy_list = [
        # ===Strategy_黄果树系列2
        {
            "strategy": "Strategy_黄果树系列4",
            "offset_list": [19],
            "hold_period": '24H',
            "is_use_spot": False,
            'cap_weight': 0.1,
            'long_cap_weight': 0,
            'short_cap_weight': 1,
            'long_select_coin_num': 0,
            'short_select_coin_num': 0.5,
            "factor_list": [
                ('VolumeMeanRatio', True, 618, 1),
            ],
            "filter_list": [
                ('BiasQ', 528, 'pct:<0.2'),
            ],
            "filter_list_post": [
                ('ZscoreAbsMeanQ', 528, 'val:<0.5'),
            ],
            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        },
    ]



# endregion


# region 淘淘沙策略魔改
class 浪淘沙多空策略魔改2000u():
    backtest_name = '浪淘沙多空魔改'
    strategy_list = [
        # ===1.大学生(资金占比0.25)
        {
            "strategy": "Strategy_大学生多头",
            "offset_list": [10],
            "hold_period": '24H',
            "is_use_spot": True,
            'cap_weight': 0.25,
            'long_cap_weight': 1,
            'short_cap_weight': 0,
            'long_select_coin_num': 0.1,
            'short_select_coin_num': 0,
            "factor_list": [
                ('VolumeUpdated', True, 200, 1),
                ('ChengLiRate', True, 200, 1),
                ('Ret', True, 200, 1),
            ],
            "filter_list": [
                ('ZfStd', 18, 'pct:<0.8'),
                ('CirculatingMcap', True, 'pct:<0.2')
            ],
            "filter_list_post": [
                ('ZfMeanQ', 936, 'val:>0.5'),
            ],
            "use_custom_func": False,
        },
        # ===2.GA(资金占比0.25)
        {
            "strategy": "Strategy_GA多头",
            "offset_list": [12],
            "hold_period": '24H',
            "is_use_spot": True,
            'cap_weight': 0.25,
            'long_cap_weight': 1,
            'short_cap_weight': 0,
            'long_select_coin_num': 0.1,
            'short_select_coin_num': 0,
            "factor_list": [
                ('RankDiff_spot', True, 1024, 1),
            ],
            "filter_list_post": [
                ('ZfMeanQ', 648, 'val:>0.5'),
            ],
            "use_custom_func": False,
        },
        # ===3.黄果树系列1(资金占比0.3)
        {
            "strategy": "Strategy_黄果树系列1",
            "offset_list": [4],
            "hold_period": '24H',
            "is_use_spot": False,
            'cap_weight': 0.25,
            'long_cap_weight': 0,
            'short_cap_weight': 1,
            'long_select_coin_num': 0,
            'short_select_coin_num': 0.5,
            "factor_list": [
                ('MinMax', False, 432, 1),
            ],
            "filter_list": [
                ('QuoteVolumeMean', 432, 'pct:<0.2', False),
            ],
            "filter_list_post": [
                ('ZscoreAbsMeanQ', 432, 'val:<0.5'),
            ],
            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        },
        # ===4.黄果树系列2(资金占比0.2)
        # {
        #     "strategy": "Strategy_黄果树系列2",
        #     "offset_list": [19],
        #     "hold_period": '24H',
        #     "is_use_spot": False,
        #     'cap_weight': 0.2,
        #     'long_cap_weight': 0,
        #     'short_cap_weight': 1,
        #     'long_select_coin_num': 0,
        #     'short_select_coin_num': 0.5,
        #     "factor_list": [
        #         ('QuoteVolumeMean', True, 528, 1),
        #     ],
        #     "filter_list": [
        #         ('BiasQ', 528, 'pct:<0.2'),
        #     ],
        #     "filter_list_post": [
        #         ('ZscoreAbsMeanQ', 528, 'val:<0.5'),
        #     ],
        #     "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        # },
        # ===5.黄果树系列3(资金占比0.1)
        {
            "strategy": "Strategy_黄果树系列3",
            "offset_list": [12],
            "hold_period": '24H',
            "is_use_spot": False,
            'cap_weight': 0.25,
            'long_cap_weight': 0,
            'short_cap_weight': 1,
            'long_select_coin_num': 0,
            'short_select_coin_num': 9999,
            "factor_list": [
                ('QuoteVolumeMean', True, 1, 1),
            ],
            "filter_list": [
                ('MinMax', 552, 'pct:<0.15'),
                ('QuoteVolumeMean', 552, 'pct:<0.15', False),
            ],
            "filter_list_post": [
                ('ZfMeanQ', 552, 'val:<0.5'),
            ],
            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        },
    ]
class 浪淘沙多空_仅空头过滤魔改2000u():
    backtest_name = '浪淘沙多空-仅空头过滤'
    strategy_list = [
        # ===1.大学生(资金占比0.25)
        {
            "strategy": "Strategy_大学生多头",
            "offset_list": [10],
            "hold_period": '24H',
            "is_use_spot": True,
            'cap_weight': 0.25,
            'long_cap_weight': 1,
            'short_cap_weight': 0,
            'long_select_coin_num': 0.1,
            'short_select_coin_num': 0,
            "factor_list": [
                ('VolumeUpdated', True, 200, 1),
                ('ChengLiRate', True, 200, 1),
                ('Ret', True, 200, 1),
            ],
            "filter_list": [
                ('ZfStd', 18, 'pct:<0.8'),
                ('CirculatingMcap', True, 'pct:<0.2')
            ],
            "use_custom_func": False,
        },
        # ===2.GA(资金占比0.25)
        {
            "strategy": "Strategy_GA多头",
            "offset_list": [12],
            "hold_period": '24H',
            "is_use_spot": True,
            'cap_weight': 0.25,
            'long_cap_weight': 1,
            'short_cap_weight': 0,
            'long_select_coin_num': 0.1,
            'short_select_coin_num': 0,
            "factor_list": [
                ('RankDiff_spot', True, 1176, 1),
            ],
            "use_custom_func": False,
        },
        # ===3.黄果树系列1(资金占比0.3)
        {
            "strategy": "Strategy_黄果树系列1",
            "offset_list": [4],
            "hold_period": '24H',
            "is_use_spot": False,
            'cap_weight': 0.3,
            'long_cap_weight': 0,
            'short_cap_weight': 1,
            'long_select_coin_num': 0,
            'short_select_coin_num': 0.5,
            "factor_list": [
                ('MinMax', False, 432, 1),
            ],
            "filter_list": [
                ('QuoteVolumeMean', 432, 'pct:<0.2', False),
            ],
            "filter_list_post": [
                ('ZscoreAbsMeanQ', 432, 'val:<0.5'),
            ],
            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        },
        # ===4.黄果树系列2(资金占比0.1)
        # {
        #     "strategy": "Strategy_黄果树系列2",
        #     "offset_list": [19],
        #     "hold_period": '24H',
        #     "is_use_spot": False,
        #     'cap_weight': 0.1,
        #     'long_cap_weight': 0,
        #     'short_cap_weight': 1,
        #     'long_select_coin_num': 0,
        #     'short_select_coin_num': 0.5,
        #     "factor_list": [
        #         ('QuoteVolumeMean', True, 528, 1),
        #     ],
        #     "filter_list": [
        #         ('BiasQ', 528, 'pct:<0.2'),
        #     ],
        #     "filter_list_post": [
        #         ('ZscoreAbsMeanQ', 528, 'val:<0.5'),
        #     ],
        #     "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        # },
        # ===5.黄果树系列3(资金占比0.2)
        {
            "strategy": "Strategy_黄果树系列3",
            "offset_list": [12],
            "hold_period": '24H',
            "is_use_spot": False,
            'cap_weight': 0.1,
            'long_cap_weight': 0,
            'short_cap_weight': 1,
            'long_select_coin_num': 0,
            'short_select_coin_num': 9999,
            "factor_list": [
                ('QuoteVolumeMean', True, 1, 1),
            ],
            "filter_list": [
                ('MinMax', 552, 'pct:<0.15'),
                ('QuoteVolumeMean', 552, 'pct:<0.15', False),
            ],
            "filter_list_post": [
                ('ZfMeanQ', 552, 'val:<0.5'),
            ],
            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        },
    ]

# endregion


# region 淘淘沙策略
class 浪淘沙多空策略2000u():
    backtest_name = '浪淘沙多空'
    strategy_list = [
        # ===1.大学生(资金占比0.25)
        {
            "strategy": "Strategy_大学生多头",
            "offset_list": [3],
            "hold_period": '24H',
            "is_use_spot": True,
            'cap_weight': 0.25,
            'long_cap_weight': 1,
            'short_cap_weight': 0,
            'long_select_coin_num': 0.1,
            'short_select_coin_num': 0,
            "factor_list": [
                ('CirculatingMcap', True, 1, 1),
            ],
            "filter_list": [
                ('ZfStd', 18, 'pct:<0.8'),
            ],
            "filter_list_post": [
                ('ZfMeanQ', 936, 'val:>0.5'),
            ],
            "use_custom_func": False,
        },
        # ===2.GA(资金占比0.25)
        {
            "strategy": "Strategy_GA多头",
            "offset_list": [6],
            "hold_period": '24H',
            "is_use_spot": True,
            'cap_weight': 0.25,
            'long_cap_weight': 1,
            'short_cap_weight': 0,
            'long_select_coin_num': 0.1,
            'short_select_coin_num': 0,
            "factor_list": [
                ('RankDiff_spot', True, 1024, 1),
            ],
            "filter_list_post": [
                ('ZfMeanQ', 648, 'val:>0.5'),
            ],
            "use_custom_func": False,
        },
        # ===3.黄果树系列1(资金占比0.3)
        {
            "strategy": "Strategy_黄果树系列1",
            "offset_list": [4],
            "hold_period": '24H',
            "is_use_spot": False,
            'cap_weight': 0.3,
            'long_cap_weight': 0,
            'short_cap_weight': 1,
            'long_select_coin_num': 0,
            'short_select_coin_num': 0.5,
            "factor_list": [
                ('MinMax', False, 432, 1),
            ],
            "filter_list": [
                ('QuoteVolumeMean', 432, 'pct:<0.2', False),
            ],
            "filter_list_post": [
                ('ZscoreAbsMeanQ', 432, 'val:<0.5'),
            ],
            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        },
        # ===4.黄果树系列2(资金占比0.1)
        {
            "strategy": "Strategy_黄果树系列2",
            "offset_list": [19],
            "hold_period": '24H',
            "is_use_spot": False,
            'cap_weight': 0.1,
            'long_cap_weight': 0,
            'short_cap_weight': 1,
            'long_select_coin_num': 0,
            'short_select_coin_num': 0.5,
            "factor_list": [
                ('QuoteVolumeMean', True, 528, 1),
            ],
            "filter_list": [
                ('BiasQ', 528, 'pct:<0.2'),
            ],
            "filter_list_post": [
                ('ZscoreAbsMeanQ', 528, 'val:<0.5'),
            ],
            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        },
        # ===5.黄果树系列3(资金占比0.1)
        {
            "strategy": "Strategy_黄果树系列3",
            "offset_list": [12],
            "hold_period": '24H',
            "is_use_spot": False,
            'cap_weight': 0.1,
            'long_cap_weight': 0,
            'short_cap_weight': 1,
            'long_select_coin_num': 0,
            'short_select_coin_num': 9999,
            "factor_list": [
                ('QuoteVolumeMean', True, 1, 1),
            ],
            "filter_list": [
                ('MinMax', 552, 'pct:<0.15'),
                ('QuoteVolumeMean', 552, 'pct:<0.15', False),
            ],
            "filter_list_post": [
                ('ZfMeanQ', 552, 'val:<0.5'),
            ],
            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        },
    ]
class 浪淘沙多空_仅空头过滤2000u():
    backtest_name = '浪淘沙多空-仅空头过滤'
    strategy_list = [
        # ===1.大学生(资金占比0.25)
        {
            "strategy": "Strategy_大学生多头",
            "offset_list": [3],
            "hold_period": '24H',
            "is_use_spot": True,
            'cap_weight': 0.25,
            'long_cap_weight': 1,
            'short_cap_weight': 0,
            'long_select_coin_num': 0.1,
            'short_select_coin_num': 0,
            "factor_list": [
                ('CirculatingMcap', True, 1, 1),
            ],
            "filter_list": [
                ('ZfStd', 18, 'pct:<0.8'),
            ],
            "use_custom_func": False,
        },
        # ===2.GA(资金占比0.25)
        {
            "strategy": "Strategy_GA多头",
            "offset_list": [6],
            "hold_period": '24H',
            "is_use_spot": True,
            'cap_weight': 0.25,
            'long_cap_weight': 1,
            'short_cap_weight': 0,
            'long_select_coin_num': 0.1,
            'short_select_coin_num': 0,
            "factor_list": [
                ('RankDiff_spot', True, 1176, 1),
            ],
            "use_custom_func": False,
        },
        # ===3.黄果树系列1(资金占比0.3)
        {
            "strategy": "Strategy_黄果树系列1",
            "offset_list": [4],
            "hold_period": '24H',
            "is_use_spot": False,
            'cap_weight': 0.3,
            'long_cap_weight': 0,
            'short_cap_weight': 1,
            'long_select_coin_num': 0,
            'short_select_coin_num': 0.5,
            "factor_list": [
                ('MinMax', False, 432, 1),
            ],
            "filter_list": [
                ('QuoteVolumeMean', 432, 'pct:<0.2', False),
            ],
            "filter_list_post": [
                ('ZscoreAbsMeanQ', 432, 'val:<0.5'),
            ],
            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        },
        # ===4.黄果树系列2(资金占比0.1)
        {
            "strategy": "Strategy_黄果树系列2",
            "offset_list": [19],
            "hold_period": '24H',
            "is_use_spot": False,
            'cap_weight': 0.1,
            'long_cap_weight': 0,
            'short_cap_weight': 1,
            'long_select_coin_num': 0,
            'short_select_coin_num': 0.5,
            "factor_list": [
                ('QuoteVolumeMean', True, 528, 1),
            ],
            "filter_list": [
                ('BiasQ', 528, 'pct:<0.2'),
            ],
            "filter_list_post": [
                ('ZscoreAbsMeanQ', 528, 'val:<0.5'),
            ],
            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        },
        # ===5.黄果树系列3(资金占比0.1)
        {
            "strategy": "Strategy_黄果树系列3",
            "offset_list": [12],
            "hold_period": '24H',
            "is_use_spot": False,
            'cap_weight': 0.1,
            'long_cap_weight': 0,
            'short_cap_weight': 1,
            'long_select_coin_num': 0,
            'short_select_coin_num': 9999,
            "factor_list": [
                ('QuoteVolumeMean', True, 1, 1),
            ],
            "filter_list": [
                ('MinMax', 552, 'pct:<0.15'),
                ('QuoteVolumeMean', 552, 'pct:<0.15', False),
            ],
            "filter_list_post": [
                ('ZfMeanQ', 552, 'val:<0.5'),
            ],
            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        },
    ]

    class 浪淘沙多空_仅多头过滤2000u():
        backtest_name = '浪淘沙多空-仅多头过滤'
        strategy_list = [
            # ===1.大学生(资金占比0.25)
            {
                "strategy": "Strategy_大学生多头",
                "offset_list": [3],
                "hold_period": '24H',
                "is_use_spot": True,
                'cap_weight': 0.25,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': 0.1,
                'short_select_coin_num': 0,
                "factor_list": [
                    ('CirculatingMcap', True, 1, 1),
                ],
                "filter_list": [
                    ('ZfStd', 18, 'pct:<0.8'),
                ],
                "filter_list_post": [
                    ('ZfMeanQ', 936, 'val:>0.5'),
                ],
                "use_custom_func": False,
            },
            # ===2.GA(资金占比0.25)
            {
                "strategy": "Strategy_GA多头",
                "offset_list": [6],
                "hold_period": '24H',
                "is_use_spot": True,
                'cap_weight': 0.25,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': 0.1,
                'short_select_coin_num': 0,
                "factor_list": [
                    ('RankDiff_spot', True, 1176, 1),
                ],
                "filter_list_post": [
                    ('ZfMeanQ', 648, 'val:>0.5'),
                ],
                "use_custom_func": False,
            },
            # ===3.黄果树系列1(资金占比0.3)
            {
                "strategy": "Strategy_黄果树系列1",
                "offset_list": [4],
                "hold_period": '24H',
                "is_use_spot": False,
                'cap_weight': 0.3,
                'long_cap_weight': 0,
                'short_cap_weight': 1,
                'long_select_coin_num': 0,
                'short_select_coin_num': 0.5,
                "factor_list": [
                    ('MinMax', False, 432, 1),
                ],
                "filter_list": [
                    ('QuoteVolumeMean', 432, 'pct:<0.2', False),
                ],
                # "filter_list_post": [
                #     ('ZscoreAbsMeanQ', 432, 'val:<0.5'),
                # ],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            # ===4.黄果树系列2(资金占比0.1)
            {
                "strategy": "Strategy_黄果树系列2",
                "offset_list": [19],
                "hold_period": '24H',
                "is_use_spot": False,
                'cap_weight': 0.1,
                'long_cap_weight': 0,
                'short_cap_weight': 1,
                'long_select_coin_num': 0,
                'short_select_coin_num': 0.5,
                "factor_list": [
                    ('QuoteVolumeMean', True, 528, 1),
                ],
                "filter_list": [
                    ('BiasQ', 528, 'pct:<0.2'),
                ],
                # "filter_list_post": [
                #     ('ZscoreAbsMeanQ', 528, 'val:<0.5'),
                # ],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            # ===5.黄果树系列3(资金占比0.1)
            {
                "strategy": "Strategy_黄果树系列3",
                "offset_list": [12],
                "hold_period": '24H',
                "is_use_spot": False,
                'cap_weight': 0.1,
                'long_cap_weight': 0,
                'short_cap_weight': 1,
                'long_select_coin_num': 0,
                'short_select_coin_num': 9999,
                "factor_list": [
                    ('QuoteVolumeMean', True, 1, 1),
                ],
                # "filter_list": [
                #     ('MinMax', 552, 'pct:<0.15'),
                #     ('QuoteVolumeMean', 552, 'pct:<0.15', False),
                # ],
                "filter_list_post": [
                    ('ZfMeanQ', 552, 'val:<0.5'),
                ],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
        ]
# endregion

# region 历史策略
class strategy_20000u_浪淘沙策略():
    backtest_name = 'strategy_20000u_浪淘沙策略'
    strategy_list = [
            # === 1.多头
            # = 1.1大学生纯多策略
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_大学生",
                "offset_list": [7],
                "hold_period": "24H",
                "is_use_spot": True,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 6,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': 0.1,
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('CirculatingMcap', True, 1, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [
                    ('ZfStd', 16, 'pct:<0.8')
                ],
                "filter_list_post": [
                    ('ZfAbsMean', 16, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_大学生",
                "offset_list": [4],
                "hold_period": "24H",
                "is_use_spot": True,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 6,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': 0.1,
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('CirculatingMcap', True, 1, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [
                    ('ZfStd', 144, 'pct:<0.8')
                ],
                "filter_list_post": [
                    ('ZfAbsMean', 144, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_大学生",
                "offset_list": [8],
                "hold_period": "24H",
                "is_use_spot": True,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 6,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': (0.1, 0.2),
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('CirculatingMcap', True, 1, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [
                    ('ZfStd', 24, 'pct:<0.8')
                ],
                "filter_list_post": [
                    ('ZfAbsMean', 24, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_大学生",
                "offset_list": [18],
                "hold_period": "24H",
                "is_use_spot": True,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 6,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': (0.1, 0.2),
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('CirculatingMcap', True, 1, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [
                    ('ZfStd', 156, 'pct:<0.8')
                ],
                "filter_list_post": [
                    ('ZfAbsMean', 156, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_大学生",
                "offset_list": [23],
                "hold_period": "24H",
                "is_use_spot": True,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 6,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': (0.2, 0.3),
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('CirculatingMcap', True, 1, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [
                    ('ZfStd', 20, 'pct:<0.8')
                ],
                "filter_list_post": [
                    ('ZfAbsMean', 20, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_大学生",
                "offset_list": [11],
                "hold_period": "24H",
                "is_use_spot": True,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 6,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': (0.2, 0.3),
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('CirculatingMcap', True, 1, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [
                    ('ZfStd', 192, 'pct:<0.8')
                ],
                "filter_list_post": [
                    ('ZfAbsMean', 192, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },

            # = 1.2 流动性纯多策略
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_流动性",
                "offset_list": [19],
                "hold_period": "24H",
                "is_use_spot": True,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 6,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': 0.1,
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('NetBuyStd', True, 96, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [
                    ('PctChange', 96, 'pct:<0.8')
                ],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_流动性",
                "offset_list": [20],
                "hold_period": "24H",
                "is_use_spot": True,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 6,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': 0.1,
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('QuoteVolumeStd', True, 48, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [
                    ('PctChange', 48, 'pct:<0.8')
                ],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_流动性",
                "offset_list": [1],
                "hold_period": "24H",
                "is_use_spot": True,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 6,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': (0.1, 0.2),
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('QuoteVolumeStd', True, 192, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [
                    ('PctChange', 192, 'pct:<0.8')
                ],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_流动性",
                "offset_list": [3],
                "hold_period": "24H",
                "is_use_spot": True,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 6,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': (0.1, 0.2),
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('QuoteVolumeMean', True, 768, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [
                    ('PctChange', 768, 'pct:<0.8')
                ],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_流动性",
                "offset_list": [3],
                "hold_period": "24H",
                "is_use_spot": True,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 6,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': (0.2, 0.3),
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('ILLQStd', True, 384, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [
                    ('PctChange', 384, 'pct:<0.8')
                ],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_流动性",
                "offset_list": [10],
                "hold_period": "24H",
                "is_use_spot": True,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 6,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': (0.2, 0.3),
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('ILLQMean', True, 3072, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [
                    ('PctChange', 3072, 'pct:<0.8')
                ],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },

            # = 1.3 动量多头
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_动量",
                "offset_list": [18],
                "hold_period": "24H",
                "is_use_spot": False,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 6,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': 0.1,
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('动量因子1', False, 3120, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_动量",
                "offset_list": [20],
                "hold_period": "24H",
                "is_use_spot": False,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 6,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': 0.1,
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('动量因子1', False, 7680, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_动量",
                "offset_list": [22],
                "hold_period": "24H",
                "is_use_spot": False,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 6,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': 0.1,
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('动量因子2', False, 16800, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_动量",
                "offset_list": [4],
                "hold_period": "24H",
                "is_use_spot": False,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 6,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': 0.1,
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('动量因子2', False, 22560, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_动量",
                "offset_list": [9],
                "hold_period": "24H",
                "is_use_spot": False,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 6,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': 0.1,
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('动量因子3', False, 9120, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_动量",
                "offset_list": [2],
                "hold_period": "24H",
                "is_use_spot": False,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 6,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': 0.1,
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('动量因子3', False, 11280, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },

            # = 1.4 反转多头
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_反转",
                "offset_list": [14, 16],
                "hold_period": "24H",
                "is_use_spot": True,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 3,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': 0.1,
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('BiasV1', True, 20160, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_反转",
                "offset_list": [5, 15],
                "hold_period": "24H",
                "is_use_spot": True,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 3,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': 0.1,
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('BiasV1', True, 22080, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_反转",
                "offset_list": [6, 10],
                "hold_period": "24H",
                "is_use_spot": True,
                # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                'cap_weight': 1 / 4 / 3,
                'long_cap_weight': 1,
                'short_cap_weight': 0,
                'long_select_coin_num': 0.1,
                'short_select_coin_num': 0,
                # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                "factor_list": [
                    ('BiasV1', True, 24000, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            },

            # === 2.空头
            # = 2.1 原版黄果树：先使用QuoteVolumeMean，再使用动量因子，资金占比为空头的0.75(总资金的0.375)
            # = 2.1.1 不加后置过滤(占比0.75，总资金的0.28125 = 0.5 * 0.75 * 0.75)
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_黄果树",
                "offset_list": [14, 21, 22],  # 只选部分offset[1, 3, 6]；
                "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
                "is_use_spot": False,  # 多头支持交易现货；
                # 资金权重。程序会自动根据这个权重计算你的策略占比
                'cap_weight': 1 * 0.75 * 0.75 / 4,
                'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
                'short_cap_weight': 1,
                # 选币数量
                'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
                'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
                # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                "factor_list": [
                    ('MinMax', False, 408, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
                ],
                "filter_list": [
                    ('QuoteVolumeMean', 408, 'pct:<0.2', False),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_黄果树",
                "offset_list": [5, 16, 9],  # 只选部分offset[1, 3, 6]；
                "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
                "is_use_spot": False,  # 多头支持交易现货；
                # 资金权重。程序会自动根据这个权重计算你的策略占比
                'cap_weight': 1 * 0.75 * 0.75 / 4,
                'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
                'short_cap_weight': 1,
                # 选币数量
                'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
                'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
                # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                "factor_list": [
                    ('MinMax', False, 360, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
                ],
                "filter_list": [
                    ('QuoteVolumeMean', 360, 'pct:<0.2', False),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_黄果树",
                "offset_list": [19, 6, 2],  # 只选部分offset[1, 3, 6]；
                "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
                "is_use_spot": False,  # 多头支持交易现货；
                # 资金权重。程序会自动根据这个权重计算你的策略占比
                'cap_weight': 1 * 0.75 * 0.75 / 4,
                'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
                'short_cap_weight': 1,
                # 选币数量
                'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
                'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
                # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                "factor_list": [
                    ('MinMax', False, 264, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
                ],
                "filter_list": [
                    ('QuoteVolumeMean', 264, 'pct:<0.2', False),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_黄果树",
                "offset_list": [1, 13, 15],  # 只选部分offset[1, 3, 6]；
                "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
                "is_use_spot": False,  # 多头支持交易现货；
                # 资金权重。程序会自动根据这个权重计算你的策略占比
                'cap_weight': 1 * 0.75 * 0.75 / 4,
                'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
                'short_cap_weight': 1,
                # 选币数量
                'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
                'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
                # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                "factor_list": [
                    ('MinMax', False, 192, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
                ],
                "filter_list": [
                    ('QuoteVolumeMean', 192, 'pct:<0.2', False),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
            },
            # = 2.1.2 加后置过滤(占比0.25，总资金的0.09375 = 0.5 * 0.75 * 0.25)
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_黄果树",
                "offset_list": [23],  # 只选部分offset[1, 3, 6]；
                "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
                "is_use_spot": False,  # 多头支持交易现货；
                # 资金权重。程序会自动根据这个权重计算你的策略占比
                'cap_weight': 1 * 0.75 * 0.25 / 4,
                'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
                'short_cap_weight': 1,
                # 选币数量
                'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
                'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
                # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                "factor_list": [
                    ('Cci', False, 264, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
                ],
                "filter_list": [
                    ('QuoteVolumeMean', 264, 'pct:<0.2', False),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
                "filter_list_post": [
                    ('ZfAbsMean', 264, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_黄果树",
                "offset_list": [7],  # 只选部分offset[1, 3, 6]；
                "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
                "is_use_spot": False,  # 多头支持交易现货；
                # 资金权重。程序会自动根据这个权重计算你的策略占比
                'cap_weight': 1 * 0.75 * 0.25 / 4,
                'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
                'short_cap_weight': 1,
                # 选币数量
                'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
                'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
                # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                "factor_list": [
                    ('Cci', False, 384, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
                ],
                "filter_list": [
                    ('QuoteVolumeMean', 384, 'pct:<0.2', False),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
                "filter_list_post": [
                    ('ZfAbsMean', 384, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_黄果树",
                "offset_list": [11],  # 只选部分offset[1, 3, 6]；
                "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
                "is_use_spot": False,  # 多头支持交易现货；
                # 资金权重。程序会自动根据这个权重计算你的策略占比
                'cap_weight': 1 * 0.75 * 0.25 / 4,
                'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
                'short_cap_weight': 1,
                # 选币数量
                'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
                'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
                # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                "factor_list": [
                    ('Cci', False, 336, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
                ],
                "filter_list": [
                    ('QuoteVolumeMean', 336, 'pct:<0.2', False),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
                "filter_list_post": [
                    ('ZfAbsMean', 336, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_黄果树",
                "offset_list": [12],  # 只选部分offset[1, 3, 6]；
                "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
                "is_use_spot": False,  # 多头支持交易现货；
                # 资金权重。程序会自动根据这个权重计算你的策略占比
                'cap_weight': 1 * 0.75 * 0.25 / 4,
                'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
                'short_cap_weight': 1,
                # 选币数量
                'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
                'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
                # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                "factor_list": [
                    ('Cci', False, 552, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
                ],
                "filter_list": [
                    ('QuoteVolumeMean', 552, 'pct:<0.2', False),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
                "filter_list_post": [
                    ('ZfAbsMean', 552, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
            },
            # = 2.2 改版黄果树：先使用动量因子，再使用QuoteVolumeMean，资金占比为空头的0.25(总资金的0.125)
            # = 2.2.1 不加后置过滤(占比0.75，总资金的0.09375 = 0.5 * 0.25 * 0.75)
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_黄果树",
                "offset_list": [17],  # 只选部分offset[1, 3, 6]；
                "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
                "is_use_spot": False,  # 多头支持交易现货；
                # 资金权重。程序会自动根据这个权重计算你的策略占比
                'cap_weight': 1 * 0.25 * 0.75 / 4,
                'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
                'short_cap_weight': 1,
                # 选币数量
                'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
                'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
                # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                "factor_list": [
                    ('QuoteVolumeMean', True, 264, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
                ],
                "filter_list": [
                    ('BiasQ', 264, 'pct:<0.2'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_黄果树",
                "offset_list": [12],  # 只选部分offset[1, 3, 6]；
                "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
                "is_use_spot": False,  # 多头支持交易现货；
                # 资金权重。程序会自动根据这个权重计算你的策略占比
                'cap_weight': 1 * 0.25 * 0.75 / 4,
                'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
                'short_cap_weight': 1,
                # 选币数量
                'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
                'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
                # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                "factor_list": [
                    ('QuoteVolumeMean', True, 576, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
                ],
                "filter_list": [
                    ('BiasQ', 576, 'pct:<0.2'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_黄果树",
                "offset_list": [17],  # 只选部分offset[1, 3, 6]；
                "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
                "is_use_spot": False,  # 多头支持交易现货；
                # 资金权重。程序会自动根据这个权重计算你的策略占比
                'cap_weight': 1 * 0.25 * 0.75 / 4,
                'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
                'short_cap_weight': 1,
                # 选币数量
                'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
                'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
                # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                "factor_list": [
                    ('QuoteVolumeMean', True, 168, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
                ],
                "filter_list": [
                    ('BiasQ', 168, 'pct:<0.2'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_黄果树",
                "offset_list": [8],  # 只选部分offset[1, 3, 6]；
                "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
                "is_use_spot": False,  # 多头支持交易现货；
                # 资金权重。程序会自动根据这个权重计算你的策略占比
                'cap_weight': 1 * 0.25 * 0.75 / 4,
                'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
                'short_cap_weight': 1,
                # 选币数量
                'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
                'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
                # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                "factor_list": [
                    ('QuoteVolumeMean', True, 360, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
                ],
                "filter_list": [
                    ('BiasQ', 360, 'pct:<0.2'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
            },
            # = 2.2.2 加后置过滤(占比0.25，总资金的0.03125 = 0.5 * 0.25 * 0.25)
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_黄果树",
                "offset_list": [21],  # 只选部分offset[1, 3, 6]；
                "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
                "is_use_spot": False,  # 多头支持交易现货；
                # 资金权重。程序会自动根据这个权重计算你的策略占比
                'cap_weight': 1 * 0.25 * 0.25 / 2,
                'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
                'short_cap_weight': 1,
                # 选币数量
                'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
                'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
                # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                "factor_list": [
                    ('QuoteVolumeMean', True, 192, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
                ],
                "filter_list": [
                    ('Cci', 192, 'pct:<0.2'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
                "filter_list_post": [
                    ('ZfAbsMean', 192, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
            },
            {
                # 策略名称。与strategy目录中的策略文件名保持一致。
                "strategy": "Strategy_黄果树",
                "offset_list": [13],  # 只选部分offset[1, 3, 6]；
                "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
                "is_use_spot": False,  # 多头支持交易现货；
                # 资金权重。程序会自动根据这个权重计算你的策略占比
                'cap_weight': 1 * 0.25 * 0.25 / 2,
                'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
                'short_cap_weight': 1,
                # 选币数量
                'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
                'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
                # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                "factor_list": [
                    ('QuoteVolumeMean', True, 552, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
                ],
                "filter_list": [
                    ('Cci', 552, 'pct:<0.2'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
                "filter_list_post": [
                    ('ZfAbsMean', 552, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
                ],
            },
        ],

class 黄果树策略():
    backtest_name = '黄果树策略'  # 回测的策略组合的名称。可以自己任意取。一般建议，一个回测组，就是实盘中的一个账户。
    strategy_list = [
        {
            # 策略名称。与strategy目录中的策略文件名保持一致。
            "strategy": "Strategy_黄果树",
            "offset_list": range(1, 24, 1),  # 只选部分offset[1, 3, 6]；
            "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
            "is_use_spot": False,  # 多头支持交易现货；
            # 资金权重。程序会自动根据这个权重计算你的策略占比
            'cap_weight': 1 * 0.75 * 0.25 / 4,
            'long_cap_weight': 0,  # 可以多空比例不同，多空不平衡对策略收益影响大
            'short_cap_weight': 1,
            # 选币数量
            'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
            'short_select_coin_num': 0.3,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
            # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
            "factor_list": [
                ('Cci', False, 384, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
            ],
            "filter_list": [
                ('QuoteVolumeMean', 384, 'pct:<0.2', False),
                # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
            ],
            "filter_list_post": [
                ('ZfAbsMean', 384, 'val:<0.5'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
            ],
        },
    ]
class 浪淘沙策略():
    backtest_name = '浪淘沙策略'  # 回测的策略组合的名称。可以自己任意取。一般建议，一个回测组，就是实盘中的一个账户。
    strategy_list = [
                        {
                            "strategy": "Strategy_大学生",
                            "offset_list": range(1, 24, 1),
                            "hold_period": '24H',
                            "is_use_spot": True,
                            'cap_weight': 1 / 2,
                            'long_cap_weight': 1,
                            'short_cap_weight': 0,
                            'long_select_coin_num': 0.1,
                            'short_select_coin_num': 0,
                            "factor_list": [
                                ('CirculatingMcap', True, 1, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                            ],
                            "filter_list": [
                                ('ZfStd', x, 'pct:<0.8'),
                            ],
                            "filter_list_post": [
                                ('ZfAbsMean', x, 'val:<0.5'),
                            ],
                            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                        } for x in [24, 96]
                    ] + [
                        {
                            "strategy": "Strategy_空头",
                            "offset_list": range(0, 24, 1),
                            "hold_period": '24H',
                            "is_use_spot": False,
                            'cap_weight': 1 / 3,
                            'long_cap_weight': 0,
                            'short_cap_weight': 1,
                            'long_select_coin_num': 0,
                            'short_select_coin_num': 0.3,
                            "factor_list": [
                                ('Cci', False, x, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                            ],
                            "filter_list": [
                                ('QuoteVolumeMean', x, 'pct:<0.2', False),
                            ],
                            "filter_list_post": [
                                ('ZfAbsMean', x, 'val:<0.5'),
                            ],
                            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                        } for x in [240, 432, 600]
                    ]

class 浪淘沙策略作业():
    backtest_name = '浪淘沙策略作业'  # 回测的策略组合的名称。可以自己任意取。一般建议，一个回测组，就是实盘中的一个账户。
    strategy_list = [
                        {
                            "strategy": "Strategy_大学生",
                            "offset_list": range(1, 24, 1),
                            "hold_period": '24H',
                            "is_use_spot": True,
                            'cap_weight': 1 / 2,
                            'long_cap_weight': 1,
                            'short_cap_weight': 0,
                            'long_select_coin_num': 0.1,
                            'short_select_coin_num': 0,
                            "factor_list": [
                                ('CirculatingMcap', True, 1, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                            ],
                            "filter_list": [
                                ('ZfStd', x, 'pct:<0.8'),
                            ],
                            "filter_list_post": [
                                ('ZfAbsMean', x, 'val:<0.9'),
                            ],
                            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                        } for x in [24, 96]
                    ] + [
                        {
                            "strategy": "Strategy_空头",
                            "offset_list": range(0, 24, 1),
                            "hold_period": '24H',
                            "is_use_spot": False,
                            'cap_weight': 1 / 3,
                            'long_cap_weight': 0,
                            'short_cap_weight': 1,
                            'long_select_coin_num': 0,
                            'short_select_coin_num': 0.3,
                            "factor_list": [
                                ('Cci', False, x, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                            ],
                            "filter_list": [
                                ('QuoteVolumeStd', x, 'pct:<0.2', False),
                            ],
                            "filter_list_post": [
                                ('ZfAbsMean', x, 'val:<0.9'),
                            ],
                            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                        } for x in [240, 432, 600]
                    ]

class 低价币中性策略():
    backtest_name = '低价币中性策略'  # 回测的策略组合的名称。可以自己任意取。一般建议，一个回测组，就是实盘中的一个账户。
    """策略配置"""
    strategy_list = [
        # === 低价币中性策略
        {
            # 策略名称。与strategy目录中的策略文件名保持一致。
            "strategy": "Strategy_低价币多空策略",
            "offset_list": list(range(0, 24, 1)),  # 只选部分offset[1, 3, 6]；
            "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
            "is_use_spot": True,  # 多头支持交易现货；
            # 资金权重。程序会自动根据这个权重计算你的策略占比
            'cap_weight': 1,
            'long_cap_weight': 1,  # 可以多空比例不同，多空不平衡对策略收益影响大
            'short_cap_weight': 1,
            # 选币数量
            'long_select_coin_num': 0.1,  # 可适当减少选币数量，对策略收益影响大
            'short_select_coin_num': 0.1,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
            # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
            "factor_list": [
                ('LowPrice', True, 168, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
            ],
            "filter_list": [
                ('LowPrice', 168, 'rank:>1', False),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
            ],
            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        },
    ]

# endregion


#region 研究策略

class 浪淘沙策略纯空_factor_X_Post():
    backtest_name = '浪淘沙策略'  # 回测的策略组合的名称。可以自己任意取。一般建议，一个回测组，就是实盘中的一个账户。
    strategy_list = [
                        {
                            "strategy": "Strategy_大学生",
                            "offset_list": range(1, 24, 1),
                            "hold_period": '24H',
                            "is_use_spot": True,
                            'cap_weight': 1 / 4,
                            'long_cap_weight': 1,
                            'short_cap_weight': 0,
                            'long_select_coin_num': 0.1,
                            'short_select_coin_num': 0,
                            "factor_list": [
                                ('CirculatingMcap', True, 1, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                            ],
                            "filter_list": [
                                ('ZfStd', x, 'pct:<0.8'),
                            ],
                            "filter_list_post": [
                                ('ZfAbsMean', x, 'val:<0.5'),
                            ],
                            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                        } for x in [24, 96]
                    ] + [
                        {
                            # 策略名称。与strategy目录中的策略文件名保持一致。
                            "strategy": "纯空_factor_X_Post",
                            "offset_list": list(range(12, 24, 2)),
                            "hold_period": "24H",  # 可以不设置
                            "is_use_spot": False,
                            # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                            "cap_weight": 1 / 4,
                            "long_cap_weight": 0,  # 策略内多头资金权重
                            "short_cap_weight": 1,
                            # 策略内空头资金权重。0.5的时候，最大回撤34%，年化收益170%，累计净值42（截止2024年9月底）；0.7的时候，最大回撤22%，年化收益141%，累计净值27（截止2024年9月底）
                            # 选币数量，1，2，3等数字代表选币的个数，0.1，0.2代表选币的比例。
                            # 选币可以为0。空头为0代表纯多，多头为0代表纯空。
                            'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
                            'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
                            # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                            "factor_list": [
                                (x, False, param, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
                            ],
                            "filter_list": [
                                ('Bias_signal', (350, -0.15), 'val:==1', False),  # 专抓"反弹无力"的弱势币 # 自己寻参啦，不要这么懒！！！
                                ('QuoteVolumeMean', param, 'pct:<0.2', False),
                            ],
                            "filter_list_post": [
                                ('ZfAbsMean', param, 'val:<0.8'),
                                ('ZfAbsMean2', param, 'val:<0.8'),
                            ],
                            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                        }
                        for param in [400, 600]  # 自己寻参啦，不要这么懒！！！
                    for x in ['Cci']  # 自己寻参啦，不要这么懒！！！
                    ]

class 纯空_factor_X_Post():
    backtest_name = '纯空_factor_X_Post'  #
    strategy_list = [
        {
            # 策略名称。与strategy目录中的策略文件名保持一致。
            "strategy": "纯空_factor_X_Post",
            "offset_list": list(range(12, 24, 2)),
            "hold_period": "24H",  # 可以不设置
            "is_use_spot": False,
            # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
            "cap_weight": 1 / 2,
            "long_cap_weight": 0,  # 策略内多头资金权重
            "short_cap_weight": 1,
            # 策略内空头资金权重。0.5的时候，最大回撤34%，年化收益170%，累计净值42（截止2024年9月底）；0.7的时候，最大回撤22%，年化收益141%，累计净值27（截止2024年9月底）
            # 选币数量，1，2，3等数字代表选币的个数，0.1，0.2代表选币的比例。
            # 选币可以为0。空头为0代表纯多，多头为0代表纯空。
            'long_select_coin_num': 0,  # 可适当减少选币数量，对策略收益影响大
            'short_select_coin_num': 0.5,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
            # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
            "factor_list": [
                (x, False, param, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
            ],
            "filter_list": [
                ('Bias_signal', (350, -0.15), 'val:==1', False),  # 专抓"反弹无力"的弱势币 # 自己寻参啦，不要这么懒！！！
                ('QuoteVolumeMean', param, 'pct:<0.2', False),
            ],
            "filter_list_post": [
                ('ZfAbsMean', param, 'val:<0.8'),
                ('ZfAbsMean2', param, 'val:<0.8'),
            ],
            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        }
        for param in [400, 600]  # 自己寻参啦，不要这么懒！！！
        for x in ['Cci']
    ]

class 研究策略():
    backtest_name = '研究策略'  # 回测的策略组合的名称。可以自己任意取。一般建议，一个回测组，就是实盘中的一个账户。
    strategy_list = [
        {
            # 策略名称。与strategy目录中的策略文件名保持一致。
            "strategy": "Strategy_研究策略",
            "offset_list": list(range(0, 24, 1)),  # 只选部分offset[1, 3, 6]；
            "hold_period": "24H",  # 小时级别可选1H到24H；也支持1D交易日级别
            "is_use_spot": True,  # 多头支持交易现货；
            # 资金权重。程序会自动根据这个权重计算你的策略占比
            'cap_weight': 1 / 2,
            'long_cap_weight': 1,  # 可以多空比例不同，多空不平衡对策略收益影响大
            'short_cap_weight': 0,
            # 选币数量
            'long_select_coin_num': 0.1,  # 可适当减少选币数量，对策略收益影响大
            'short_select_coin_num': 0,  # 四种形式：整数， 小数，'long_nums', 区间选币：(0.1, 0.2), (1, 3)
            # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
            "factor_list": [
                ('KyleLambda', False, 230, 1),  # 多空因子名（和factors文件中相同），排序方式，参数，权重。支持多空分离，多空选币因子不一样；
            ],
            "filter_list": [
                ('ZfStd', x, 'pct:<0.8'),  # 后置过滤filter_list_post，三种形式：pct, rank, val；支持多空分离，多空过滤因子不一样；
            ],
            "filter_list_post": [
                ('ZfAbsMean', x, 'val:<0.9'),
            ],
            "use_custom_func": False  # 使用系统内置因子计算、过滤函数
        } for x in [24, 96]
    ]+ [
            {
                "strategy": "Strategy_空头",
                "offset_list": range(0, 24, 1),
                "hold_period": '24H',
                "is_use_spot": False,
                'cap_weight': 0,
                'long_cap_weight': 0,
                'short_cap_weight': 1,
                'long_select_coin_num': 0,
                'short_select_coin_num': 0.3,
                "factor_list": [
                    ('Cci', False, x, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                ],
                "filter_list": [
                    ('QuoteVolumeMean', x, 'pct:<0.2', False),
                ],
                "filter_list_post": [
                    ('ZfAbsMean', x, 'val:<0.9'),
                ],
                "use_custom_func": False  # 使用系统内置因子计算、过滤函数
            } for x in [240, 432, 600]
        ]
#endregion